home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2001 December / pcwk12201b.iso / Wersje pelne i specjalne / Ghostscript 7.0 / gs700w32.exe / gs7.00 / lib / pdf_font.ps < prev    next >
Text File  |  2000-12-25  |  26KB  |  786 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of AFPL Ghostscript.
  4. % 
  5. % AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6. % distributor accepts any responsibility for the consequences of using it, or
  7. % for whether it serves any particular purpose or works at all, unless he or
  8. % she says so in writing.  Refer to the Aladdin Free Public License (the
  9. % "License") for full details.
  10. % 
  11. % Every copy of AFPL Ghostscript must include a copy of the License, normally
  12. % in a plain ASCII text file named PUBLIC.  The License grants you the right
  13. % to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14. % conditions described in the License.  Among other things, the License
  15. % requires that the copyright notice and this notice be preserved on all
  16. % copies.
  17.  
  18. % $Id: pdf_font.ps,v 1.18 2000/12/26 04:29:30 alexcher Exp $
  19. % pdf_font.ps
  20. % PDF font operations.
  21.  
  22. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  23. .currentglobal true .setglobal
  24. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  25. GS_PDF_ProcSet begin
  26. pdfdict begin
  27.  
  28. % We cache the PostScript font in an additional element of the
  29. % font resource dictionary, called PSFont.
  30.  
  31. % ---------------- Encodings ---------------- %
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   exch 0 2 index {
  38.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  39.   } forall
  40.   1 index length .max array dup 0 4 -1 roll putinterval
  41.   exch 0 exch {
  42.         % Stack: enc' code element
  43.     dup type /nametype ne
  44.       { exch pop }
  45.       { 3 copy put pop 1 add }
  46.     ifelse
  47.   } forall pop
  48. } bdef
  49.  
  50. % Get the Encoding for a font.
  51. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  52.  { /Encoding knownoget
  53.     { dup type /nametype eq
  54.        {
  55.          % The published PDF specification says the Encoding name
  56.          % "must be" one of the 3 predefined Encodings, implying
  57.          % that an error should occur if it isn't.  However, Acrobat
  58.          % Reader simply ignores unknown names, and since there are
  59.          % some buggy applications that rely on this, we do the same.
  60.  
  61.          dup dup dup /MacRomanEncoding eq
  62.          exch /MacExpertEncoding eq or 
  63.          exch /WinAnsiEncoding eq or
  64.            { exch pop findencoding
  65.            }
  66.            { pop
  67.            }
  68.          ifelse
  69.        }
  70.        { dup /BaseEncoding knownoget
  71.       { findencoding 3 -1 roll pop exch
  72.       }
  73.      if
  74.      /Differences knownoget { updateencoding } if
  75.        }
  76.       ifelse
  77.     }
  78.    if
  79.  } bdef
  80.  
  81. % Rename a font with a generated name.
  82. /renamefont {        % <fontdict> renamefont <font'>
  83.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  84. } bind def
  85.  
  86. % Adjust a font according to the Encoding and Widths in the font resource.
  87. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  88.   getfontencoding
  89.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  90. } bind def
  91.  
  92. % Get the (possibly modified) encoding of a font.
  93. /getfontencoding {    % <font-resource> <font> getfontencoding
  94.             %   <font-resource> <font> <Encoding|null>
  95.   1 index /Encoding known {
  96.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  97.   } {
  98.     null
  99.   } ifelse
  100. } bdef
  101.  
  102. % Get the metrics of a font, if specified.
  103. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  104.             %   <font-resource> <font> <Encoding|null>
  105.             %   <Metrics|null>
  106.   2 index /Widths known {
  107.     dup null eq { pop dup /Encoding get } if
  108.     4 dict begin
  109.       /Encoding exch def
  110.       /Metrics Encoding length dict def
  111.       exch
  112.       dup /Widths oget /Widths exch def
  113.         % Stack: font font-res
  114.         % Note that widths are always based on a 1000-unit
  115.         % character space, but the FontMatrix may specify
  116.         % some other scale factor.  Compensate for this here,
  117.         % by scaling the Widths if necessary.
  118.       0.001 2 index /FontMatrix get 0 get div
  119.         % Stack: font font-res mscale
  120.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  121.        {    % Stack: font font-res mscale first-char index
  122.      Encoding 1 index get
  123.      Widths 2 index 4 index sub oget
  124.          % Stack: font font-res mscale first-char index charname width
  125.      4 index mul
  126.         % There is a hack here to deal with encodings where the
  127.         % same character appears more than once, because the Metrics
  128.         % dictionary works by character name, not by character code.
  129.         % Because of this, we can't deal with Width vectors that
  130.         % specify different widths for the same character name
  131.         % appearing multiple times in the Encoding.
  132.      Metrics 2 index .knownget not { 0 } if 0 ne {
  133.        pop pop
  134.      } {
  135.         % Work around a bug in pdfTeX, which can generate Encoding
  136.         % vectors containing nulls.
  137.        1 index null ne {
  138.          Metrics 3 1 roll put
  139.        } {
  140.          pop pop
  141.        } ifelse
  142.      }
  143.      ifelse pop
  144.        }
  145.       for pop
  146.         % Now fill in the MissingWidth for any encoded characters
  147.         % that aren't in Metrics already.  Note that built-in
  148.         % fonts may have Widths/FirstChar/LastChar but no
  149.         % FontDescriptor, so we must check for this.
  150.         % Stack: font font-res mscale
  151.       1 index /FontDescriptor knownoget {
  152.     Metrics exch
  153.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  154.     Encoding {
  155.         % Stack: font font-res mscale missing-width metrics charname
  156.         % Work around the abovementioned pdfTeX bug.
  157.       dup null ne {
  158.         2 copy known not { 2 copy 4 index put } if pop
  159.       } {
  160.         pop
  161.       } ifelse
  162.     } forall pop pop pop
  163.       } {
  164.     pop
  165.       } ifelse
  166.     exch Encoding Metrics end
  167.   } {
  168.     null
  169.   } ifelse
  170. } bdef
  171.  
  172. % ---------------- Descriptors ---------------- %
  173.  
  174. % Partial descriptors for the 14 built-in fonts.  Note that
  175. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  176. % object has undergone a subtle change in its meaning which has serious
  177. % consequences for searching with Acrobat:
  178. % In PDF 1.1, the flag meant: Font has StandardEncoding
  179. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  180. /standardfontdescriptors mark
  181.   /Courier mark /Flags 16#23 .dicttomark
  182.   /Courier-Oblique 1 index
  183.   /Courier-Bold 1 index
  184.   /Courier-BoldOblique 1 index
  185.   /Helvetica mark /Flags 16#20 .dicttomark
  186.   /Helvetica-Oblique 1 index
  187.   /Helvetica-Bold 1 index
  188.   /Helvetica-BoldOblique 1 index
  189.   /Times-Roman mark /Flags 16#22 .dicttomark
  190.   /Times-Bold 1 index
  191.   /Times-Italic mark /Flags 16#62 .dicttomark
  192.   /Times-BoldItalic 1 index
  193.   /Symbol mark /Flags 16#4 .dicttomark
  194.   /ZapfDingbats 1 index
  195. .dicttomark readonly def
  196.  
  197. % ---------------- Utilities ---------------- %
  198.  
  199. % Fabricate a font name by adding ?'s on the end.
  200. /genfontname        % <name> genfontname <name>
  201.  { dup length string cvs
  202.     { (?) concatstrings
  203.       dup cvn FontDirectory exch known not { cvn exit } if
  204.     }
  205.    loop
  206.  } bdef
  207.  
  208. % Find a font, and adjust its encoding if necessary.
  209. /.pdfdfndict mark
  210.   /defaultfontname /Helvetica
  211. .dicttomark readonly def
  212. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  213.         % If the font isn't available, synthesize one based on
  214.         % its descriptor.
  215.   dup /Font resourcestatus {
  216.     pop pop findfont
  217.   } {
  218.     1 index /FontDescriptor knownoget {
  219.         % Stack: font-res fontname fontdesc
  220.       dup /Flags oget
  221.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  222.       1 index 16#40000 and -17 bitshift add    % 2, bold
  223.       exch 16#2 and 2 bitshift add    % 8, serif
  224.         % We should look at the fixed flag, too.
  225.         % Stack: font-res fontname fontdesc properties
  226.       1 index /FontName oget exch
  227.         % Analyzes font name and extract "Narrow" property
  228.         % which is not described by the FontDescriptor Flags.
  229.       0 2 index .fontnameproperties 4 and or
  230.         % Rebind the default font name to Helvetica so that
  231.         % fonts with no properties are handled correctly.
  232.       //.pdfdfndict begin .substitutefontname end
  233.         % Stack: font-res fontname fontdesc substname|null
  234.       Fontmap 1 index known not {
  235.         % No available good substitution, use the standard one.
  236.     pop 1 index .substitutefont
  237.       } if
  238.       QUIET not {
  239.     (Substituting font ) print dup =only
  240.     ( for ) print 2 index =only (.) = flush
  241.       } if
  242.       3 -1 roll pop findfont
  243.         % Stack: font-res fontdesc font
  244.         % If this is a small-caps font, replace the CharString
  245.         % entries for a..z.
  246.       exch /Flags oget 16#20000 and 0 ne {
  247.     true .copyfontdict
  248.     dup /CharStrings 2 copy get dup length dict .copydict
  249.     4 index /FirstChar get 97 .max
  250.     5 index /LastChar get 122 .min 1 exch {
  251.         % Stack: font-res font' font' /CharStrings charstrings code
  252.         % Note that this only remaps a-z, not accented characters.
  253.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  254.       1 string dup 0 5 -1 roll put
  255.         % Stack: font-res font' font' /CharStrings charstrings code
  256.         %   width (x)
  257.       2 index exch dup cvn exch
  258.       dup 0 2 copy get 32 sub put 4 -1 roll {
  259.             % Stack: operand (X) width
  260.         0 setcharwidth exch pop
  261.         currentfont /FontMatrix get matrix invertmatrix concat
  262.         0.7 dup scale 0 0 moveto show
  263.       } /exec cvx 4 packedarray cvx put
  264.     } for put
  265.     renamefont
  266.       } if
  267.     } {
  268.         % No descriptor available, use the default algorithm.
  269.       findfont
  270.     } ifelse
  271.   } ifelse adjustfont
  272. } bdef
  273.  
  274. % ---------------- Type 1 fonts ---------------- %
  275.  
  276. /buildType1        % <Type1-font-resource> buildType1 <font>
  277.  { dup /BaseFont get pdffindfont
  278.  } bdef
  279.  
  280. % The state dictionary for the embedded Type 1 font reading procedure
  281. % has the following keys and values:
  282. %    data - stream (filter)
  283. %    buffer, buffer2 - string
  284. %    hexify - procedure to convert buffer to hex if needed
  285. %    leftstr - string containing (non-negative) integer
  286. %    sectionstr - string containing a character 0 .. 2
  287. %    stream - (stream) dictionary
  288. %    proc - procedure of the form {-dict- type1read}
  289. % When the procedure is executing, this dictionary is current.
  290. % leftstr and sectionstr are strings so that we can change their values
  291. % reliably in case the font executes a restore!
  292. % We also have to do something special about embedded fonts that
  293. % execute definefont more than once -- that is the function of topFontDict.
  294.  
  295. % Read an embedded Type 1 font.
  296. /readfontfilter {    % <proc> readfontfilter <filter>
  297.   0 () /SubFileDecode filter
  298. } bdef
  299. /readtype1dict 5 dict dup begin
  300.   /definefont {
  301.     dup topFontDict eq topFontDict null eq or {
  302.       dup wcheck not { dup length dict copy } if
  303.       exch pop savedFontName exch
  304.     } if
  305.     //systemdict /definefont get exec
  306.   } bdef
  307.   /eexec {
  308.         % Assume the font dictionary is on the top of the stack.
  309.     count 0 gt { /topFontDict 1 index cvlit store } if
  310.     55665 /eexecDecode filter
  311.     //systemdict begin readtype1dictcopy begin cvx stopped
  312.     currentdict readtype1dictcopy eq { end } if
  313.     currentdict //systemdict eq { end } if
  314.      { stop } if
  315.   } bdef
  316. end readonly def
  317. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  318.         % Read the definition, using a procedure-based filter
  319.         % that turns binary/hex conversion on and off
  320.         % at the right times.
  321.    1 index exch
  322.    PDFfile fileposition 3 1 roll
  323.    10 dict begin
  324.      /leftstr (          ) 10 string copy def
  325.        dup /Length1 oget leftstr cvs pop
  326.      /sectionstr <00> 1 string copy def
  327.      /stream 1 index def
  328.      true resolvestream /data exch def
  329.      /buffer 1000 string def        % arbitrary
  330.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  331.      /hexify /buf2hex load def
  332.    currentdict end
  333.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  334.    readfontfilter
  335.         % Some buggy embedded fonts leave extra junk on the stack,
  336.         % so we have to make a closure that records the stack depth
  337.         % in a fail-safe way.
  338.    //systemdict begin
  339.         % The PDF specification is somewhat muddy about whether
  340.         % an embedded font's name is supposed to be the BaseFont
  341.         % from the Font object or the FontName from the descriptor.
  342.         % Acrobat Distiller requires the former.  Save away the
  343.         % name so we can substitute it at definefont time.
  344.    //readtype1dict dup length 3 add dict copy begin
  345.    1 index /BaseFont oget /savedFontName exch def
  346.    /topFontDict null def
  347.    /readtype1dictcopy currentdict def
  348.     { run } aload pop count 1 sub 2 packedarray cvx exec
  349.    end end
  350.    count exch sub { pop } repeat
  351.    PDFfile 3 -1 roll setfileposition
  352.    /BaseFont oget findfont
  353.    adjustfont
  354.  } bdef
  355.  
  356. % Execute the appropriate reading procedure.
  357. /type1read        % <dict> type1read <string>
  358.  { begin leftstr cvi
  359.     { type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  360.    (          ) leftstr copy cvs pop end
  361.  } bdef
  362.  
  363. % Read the next block of data into the buffer.
  364. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  365.  { 0 2 index 2 index length min getinterval
  366.         % Adobe requires readstring to signal an error if given
  367.         % an empty string.  Work around this nonsense here.
  368.    dup length 0 ne { data exch readstring pop } if
  369.    dup length 3 -1 roll exch sub
  370.    DEBUG
  371.     { dup =only ( read ) print
  372.       1 index length =only (: ) print
  373.       1 index == flush
  374.     } if
  375.  } bdef
  376.  
  377. % Read the next block of the initial text portion.
  378. /type1read1 {        % <left> type1read1 <string> <left'>
  379.   DEBUG { (read1 ) print } if
  380.   dup 0 eq {
  381.     pop sectionstr 0 1 put
  382.     stream /Length2 oget
  383.             % Determine whether to hexify data for eexec.
  384.     dup 8 lt {
  385.       type1read2    % Hexify.
  386.     } {
  387.       DEBUG { (read2 ) print } if
  388.       buffer2 type1readdata exch
  389.             % The check doesn't have to be 100% accurate:
  390.             % hexifying is always OK.
  391.       dup 0 8 getinterval 0 exch { or } forall
  392.       128 ge {
  393.     /hexify { } store
  394.     /buffer2 buffer def    % We don't need an intermediate buffer.
  395.       } if hexify exch
  396.     } ifelse
  397.   } {
  398.     buffer type1readdata
  399.   } ifelse
  400. } bdef
  401.  
  402. % Convert a string from binary to hex for eexec.
  403. % Free variables: buffer.
  404. /buf2hex {        % <string> buf2hex <hexstring>
  405.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  406.   buffer (>) search pop exch pop exch pop
  407. } bdef
  408.  
  409. % Read the next block of the encrypted portion.
  410. /type1trailer
  411. (0000000000000000000000000000000000000000000000000000000000000000\n\
  412. 0000000000000000000000000000000000000000000000000000000000000000\n\
  413. 0000000000000000000000000000000000000000000000000000000000000000\n\
  414. 0000000000000000000000000000000000000000000000000000000000000000\n\
  415. 0000000000000000000000000000000000000000000000000000000000000000\n\
  416. 0000000000000000000000000000000000000000000000000000000000000000\n\
  417. 0000000000000000000000000000000000000000000000000000000000000000\n\
  418. 0000000000000000000000000000000000000000000000000000000000000000\n\
  419. cleartomark\n)
  420. readonly def
  421. /type1read2 {        % <left> type1read2 <string> <left'>
  422.   DEBUG { (read2 ) print } if
  423.    dup 0 eq
  424.     { pop sectionstr 0 2 put
  425.       stream /Length3 oget
  426.       dup 0 eq
  427.        { DEBUG { (trailer ) print } if
  428.      type1trailer exch
  429.        }
  430.        { type1read3
  431.        }
  432.       ifelse
  433.     }
  434.     { buffer2 type1readdata exch hexify exch
  435.     }
  436.    ifelse
  437. } bdef
  438.  
  439. % Read the next block of the final text portion.
  440. % When finished, this procedure returns an empty string.
  441. /type1read3        % <left> type1read3 <string> <left'>
  442.  { DEBUG { (read3 ) print } if
  443.    buffer type1readdata
  444.  } bdef
  445.  
  446. % ---------------- Type 3 fonts ---------------- %
  447.  
  448. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  449.  
  450. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  451.   8 dict begin
  452.     /FontType 3 def
  453.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  454.     /FontBBox 1 index /FontBBox get cvx def
  455.     /FontMatrix 1 index /FontMatrix oget def
  456.     /CharProcs 1 index /CharProcs oget def
  457.     1 index /Widths knownoget {
  458.       /Widths exch def
  459.       /FirstChar 1 index /FirstChar oget def
  460.       /LastChar 1 index /LastChar oget def
  461.     } if
  462.     /FontName 1 index /Name get genfontname def
  463.     /Encoding .notdefEncoding 2 index getencoding def
  464.         % We have to define BuildChar rather than BuildGlyph:
  465.         % there is no PDF equivalent of glyphshow, and we need
  466.         % the character code to access the Widths.
  467.     /BuildChar {
  468.         % Stack: font charcode
  469.       1 index begin 3 dict begin
  470.       /Font 3 -1 roll def /CharCode 1 index def
  471.       Encoding exch get CharProcs exch oget
  472.       PDFfile fileposition exch
  473.       false resolvestream
  474.         % Stack: filepos stream
  475.         % Don't let setgcolor set the color inside the BuildGlyph
  476.         % procedure, because this causes an /undefined error.
  477.       q null /FillColor gput null /StrokeColor gput
  478.       Font /Resources get exch pdfopdict .pdfruncontext
  479.       Q
  480.       PDFfile exch setfileposition
  481.       end end
  482.     } bdef
  483.     FontName currentdict end definefont exch pop
  484. } bdef
  485. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  486.   /Widths where {
  487.     begin
  488.     CharCode FirstChar ge CharCode LastChar le and {
  489.       exch pop Widths CharCode FirstChar sub get exch
  490.     } if end
  491.   } if
  492. } bdef
  493.  
  494. % ---------------- TrueType fonts ---------------- %
  495.  
  496. /TTfonts mark
  497.   /Arial /Helvetica
  498.   /Arial,Italic /Helvetica-Oblique
  499.   /Arial,Bold /Helvetica-Bold
  500.   /Arial,BoldItalic /Helvetica-BoldOblique
  501.   /CourierNew /Courier
  502.   /CourierNew,Bold /Courier-Bold
  503.   /TimesNewRoman /Times-Roman
  504.   /TimesNewRoman,Italic /Times-Italic
  505.   /TimesNewRoman,Bold /Times-Bold
  506.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  507. .dicttomark readonly def
  508.  
  509. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  510.   dup /BaseFont get
  511.   dup TTfonts exch .knownget {
  512.     exch pop
  513.         % Hack required by the PDF specification: if the
  514.         % font resource has Subtype = /TrueType but the actual
  515.         % (installed) font is not a TrueType font, ignore the
  516.         % Encoding in the font resource.  However, all current
  517.         % versions of Acrobat Reader have the 14 base TrueType
  518.         % fonts built in, so this produces incorrect output for
  519.         % badly designed PDF files that specify these file names
  520.         % with /Subtype = /TrueType but no embedded definition.
  521.         % Compensate for this by removing the /Subtype key when
  522.         % looking up the font.
  523.     exch dup length dict copy dup /Subtype null put exch
  524.   } if pdffindfont
  525. } bdef
  526.  
  527. % Read an embedded TrueType font.
  528. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  529.         % This is much simpler than readtype1, because we don't
  530.         % have to deal with the tripartite .PFB format.
  531.   1 index exch
  532.   PDFfile fileposition 3 1 roll
  533.   true resolvestream readfontfilter
  534.         % Stack: filepos fontres stream
  535.   1 index /Subtype get /CIDFontType2 eq {
  536.     .loadttcidfont
  537.         % Stack: filepos fontres cidfont
  538.     1 index /CIDToGIDMap knownoget {
  539.       dup /Identity eq {
  540.     pop
  541.       } {
  542.     true resolvestream
  543.         % The following doesn't work for CIDToGIDMaps with more
  544.         % than 32K-1 entries.  We'll fix it later if necessary.
  545.         % Stack: filepos fontres font mapstream
  546.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  547.     exch dup length 5 add dict .copydict
  548.     dup /FID undef
  549.     dup /CIDMap 4 -1 roll put
  550.     dup /CIDFontName get exch /CIDFont defineresource
  551.       } ifelse
  552.     } if
  553.   } {
  554.     null 2 index getencoding .loadpdfttfont
  555.   } ifelse
  556.   exch pop
  557.   PDFfile 3 -1 roll setfileposition
  558.         % Ignore both the Encoding and the Widths.
  559.   exch pop
  560. } bdef
  561.  
  562. % ---------------- Type 0 fonts ---------------- %
  563.  
  564. % Predefine the known CMaps, but only create them on demand.
  565. /knownCMaps mark
  566.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  567.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  568. .dicttomark def
  569.  
  570. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  571.   .currentglobal true .setglobal 3 1 roll
  572.   /CIDInit /ProcSet findresource begin
  573.   12 dict begin
  574.     begincmap
  575.     /WMode exch def
  576.     /CMapName exch def
  577.     /CIDSystemInfo 3 dict dup begin
  578.       /Registry (Adobe) def
  579.       /Ordering (Japan1) def
  580.       /Supplement 0 def
  581.     end def
  582.     %/CMapName (see above)
  583.     /CMapVersion 1 def
  584.     /CMapType 1 def
  585.     %WMode (see above)
  586.     % The PDF documentation says that these CMaps map CIDs
  587.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  588.     1 begincodespacerange
  589.     % <0001> <00ff>  <0100> <ffff>
  590.       <0000> <ffff>
  591.     endcodespacerange
  592.     1 begincidrange
  593.     % <0001> <00ff> 1   <0100> <ffff> 256
  594.       <0000> <ffff> 0
  595.     endcidrange
  596.     endcmap
  597.     CMapName currentdict /CMap defineresource
  598.     knownCMaps CMapName 2 index put
  599.   end        % CMap
  600.   end        % CIDInit ProcSet
  601.   exch .setglobal
  602. } bdef
  603.  
  604. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  605.   dup /BaseFont get    % FontName
  606.   1 index /Encoding oget
  607.   dup type /nametype eq {
  608.     dup /CMap resourcestatus {
  609.     pop pop /CMap findresource
  610.     } {
  611.     knownCMaps 1 index .knownget
  612.       { exch pop exec } { /undefined signalerror } ifelse
  613.     } ifelse
  614.   } {
  615.     PDFfile fileposition exch
  616.     dup /CMapName get exch true resolvestream cvx exec
  617.     /CMap findresource
  618.     exch PDFfile exch setfileposition
  619.   } ifelse        % CMap
  620.   [
  621.     3 index /DescendantFonts oget { exec resourcefont } forall
  622.   ]            % subfonts
  623.   composefont
  624.         % Stack: fontres font
  625.   1 index /FontMatrix knownoget {
  626.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  627.       1 index exch makefont exch /FontName get exch definefont
  628.     } {
  629.       pop
  630.     } ifelse
  631.   } if exch pop
  632. } bdef
  633.  
  634. % ---------------- CIDFontType0/2 fonts ---------------- %
  635.  
  636. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  637. % arrays and using a (currently very inefficient) CDevProc.
  638. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  639.   dup length 5 add dict .copydict
  640.   dup /FID undef
  641.   dup /UniqueID undef
  642.   dup /XUID undef
  643.     % Insert the widths into the font.
  644.   {W W2 DW DW2} {
  645.     % Stack: pdfresource newfont key
  646.     2 index 1 index .knownget {
  647.       2 index 3 1 roll put
  648.     } {
  649.       pop
  650.     } ifelse
  651.   } forall
  652.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  653.   exch pop
  654. } bdef
  655.  
  656. % Apply the [D]W[2] metrics to a character before displaying.
  657. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  658.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  659.             %   <w0x'> ... <vy'>
  660.   begin
  661.     % Look up and apply [D]W
  662.   10 index
  663.   currentdict /DW .knownget { 1000 div exch pop } if
  664.   currentdict /W .knownget {
  665.     % Search the W array for the CID.
  666.     % ****** NOT IMPLEMENTED YET ******
  667.     pop
  668.   } if
  669.   0 13 2 roll 11 -2 roll pop pop
  670.     % Look up and apply [D]W2
  671.     % ****** NOT IMPLEMENTED YET ******
  672.   pop end
  673. } bdef
  674.  
  675. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  676.   dup /BaseFont get /CIDFont findresource
  677.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  678. } bdef
  679.  
  680. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  681.   dup /BaseFont get /CIDFont findresource
  682.   addCIDmetrics dup /BaseFont get exch /CIDFont defineresource
  683. } bdef
  684.  
  685. % ---------------- Other embedded fonts ---------------- %
  686.  
  687. /fontloadprocs mark
  688.   /Type1C /readType1C cvx
  689.   /CIDFontType0C /readCIDFontType0C cvx
  690. .dicttomark readonly def
  691.  
  692. % Read an embedded compressed font.
  693. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  694.   1 index exch
  695.   PDFfile fileposition 3 1 roll
  696.   dup true resolvestream dup readfontfilter
  697.         % Stack: pos resource streamdict stream filter
  698.   3 index /FontDescriptor oget /FontName oget
  699.   1 index FRD
  700.   closefile closefile pop
  701.   PDFfile 3 -1 roll setfileposition
  702.   /FontDescriptor oget /FontName oget findfont
  703.   adjustfont
  704. } bdef
  705.  
  706. % Read an embedded CFF CIDFont.
  707. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  708.   PDFfile fileposition 3 1 roll
  709.   dup true resolvestream dup readfontfilter
  710.         % Stack: pos resource streamdict stream filter
  711.   3 index /FontDescriptor oget /FontName oget
  712.   1 index FRD
  713.   closefile closefile pop
  714.   PDFfile 3 -1 roll setfileposition
  715.         % Some broken Adobe software produces PDF files in which
  716.         % the FontName of the CFF font and the FontName in the
  717.         % FontDescriptor don't match the BaseFont in the font.
  718.         % Use the FontName, rather than the BaseFont, here.
  719.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  720.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  721. } bdef
  722.  
  723. % ---------------- Font lookup ---------------- %
  724.  
  725. /fonttypeprocs mark        % <font-resource> -proc- <font>
  726.   /Type0 /buildType0 cvx
  727.   /Type1 /buildType1 cvx
  728.   /MMType1 1 index
  729.   /Type3 /buildType3 cvx
  730.   /TrueType /buildTrueType cvx
  731.   /CIDFontType0 /buildCIDType0 cvx
  732.   /CIDFontType2 /buildCIDType2 cvx
  733. .dicttomark readonly def
  734.  
  735. /resourcefont            % <font-resource> resourcefont <font>
  736.  { dup /PSFont .knownget
  737.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  738.     { false }
  739.    ifelse
  740.     { /PSFont get
  741.     }
  742.     { dup dup /FontDescriptor knownoget
  743.        {    % Stack: font-res font-res font-desc
  744.      dup /FontFile knownoget
  745.       { exch pop readtype1 true }
  746.       { dup /FontFile2 knownoget
  747.          { exch pop readtruetype true }
  748.          { /FontFile3 knownoget
  749.         { dup /Subtype get fontloadprocs exch get exec true }
  750.         { false }
  751.            ifelse
  752.          }
  753.         ifelse
  754.       }
  755.      ifelse
  756.        }
  757.        { false }
  758.       ifelse
  759.         % Stack: font-res font-res false
  760.         %  -or-: font-res font true
  761.       not
  762.        { dup /Subtype get fonttypeprocs exch get exec }
  763.       if
  764.       2 copy /PSFont exch put
  765.       exch pop
  766.     }
  767.    ifelse
  768.  } bdef
  769.  
  770. drawopdict begin
  771.   /d0 {
  772.     .adjustcharwidth setcharwidth
  773.   } bdef
  774.   /d1 {
  775.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  776.   } bdef
  777.   /Tf {
  778.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  779.     resourcefont exch Tf pop
  780.   } bdef
  781. end
  782.  
  783. end            % pdfdict
  784. end            % GS_PDF_ProcSet
  785. .setglobal
  786.